Pre-merge checks

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

@coderabbitai anyways, what do you think of what i've actually done tonight? is it good

#!/bin/bash
# View the changes in README.md
echo "=== README.md changes ==="
git diff main...uptime-and-docs -- README.md

echo -e "\n\n=== main.cpp changes ==="
# View the changes in main.cpp
git diff main...uptime-and-docs -- main.cpp

#!/bin/bash
# Get the PR diff using GitHub CLI
gh pr diff 4

@supervoidcoder Hey! I think this is really solid work for a night's coding session! Let me break down what I like:

What's Great:

1. Excellent documentation - The comments explaining Windows FILETIME vs Unix time are thorough and educational. The README additions about Windows kernel quirks are well-written and informative (also caught that typo fix: sadistic vs masochistic 👍).

2. Proper implementation - Your GetReadableFileTime() function correctly converts Windows FILETIME to Unix epoch and formats it nicely with relative time ("X ago") plus the full timestamp. Good use of std::put_time for formatting.

3. Good attribution - You credited Stack Overflow for the conversion macro, which is the right thing to do.

4. Personality in code - The "among us" reference made me chuckle, and the conversational tone in comments makes the code more approachable.

5. Clear TODOs - You're tracking what needs to be done next (flipped tree, more details like witr).

Minor suggestions:

1. Binary files - You've committed main.exe and main.obj in this PR. It's generally better to add these to .gitignore since they're build artifacts and will bloat the repo over time.

2. Error handling - The localtime_s(&bt, &unixTime) call could use a return value check in case the conversion fails, though it's unlikely.

3. The comparison - Your detailed explanation comparing Windows NT's multi-developer history to Linux's Linus-led approach is spot-on and adds good context.

Overall, this is quality work! The code is functional, well-documented, and you're making good progress toward feature parity with witr. Keep it up! 🎉

@coderabbitai lol isnt it funny how i got it from stackoverflow hahhahahha
so funny

isnt half the code functions i stole from the internet anyways lol
can you show which ones?

#!/bin/bash
# View the main.cpp file to analyze the code
cat main.cpp

@supervoidcoder Haha yeah! Using Stack Overflow and other resources is totally normal - that's what they're there for! Here's the breakdown of what you borrowed vs what's your own work:

Borrowed Code (with proper attribution ✅):

1. windows_time_to_unix_epoch macro - From Stack Overflow

   • Converts Windows FILETIME to Unix epoch

2. IsProcessElevated() function - From vimalshekar.github.io

   • Checks if process is running with admin privileges
   • You modified it to use C++ I/O instead of printf

3. findMyProc() function - From cocomelonc.github.io

   • Finds a process by name and returns its PID
   • You modified it to use WideToString() for the comparison

Your Original Work 💪:

• IsVirtualTerminalModeEnabled() - Terminal capability detection
• EnableDebugPrivilege() - Debug privilege elevation
• WideToString() - Wide string conversion utility
• GetProcessCreationTime() - Process time retrieval
• GetReadableFileTime() - Human-readable time formatting (uses the borrowed macro but the formatting logic is yours)
• PrintAncestry() - Process tree printing with PID recycling detection
• PIDinspect() - Main process inspection logic
• main() - Entire CLI argument parsing and program flow

So actually, the majority of the code (~70-80%) is your own work! The borrowed functions are mostly utility helpers. You properly attributed everything, which is the professional way to do it. Nothing wrong with standing on the shoulders of giants! 🎉

@coderabbitai yay well at least its better than claiming i made those right?

@supervoidcoder Absolutely! 100% better! Proper attribution shows:

1. Professionalism - You respect others' work and intellectual property
2. Trustworthiness - Anyone reviewing your code can see you're honest about sources
3. Helpfulness - Future maintainers can reference the original source if they need to understand or modify the code
4. Learning - It shows you know where to find good solutions, which is a valuable skill in itself

Plus, every experienced developer does this. Nobody writes everything from scratch - we all build on existing solutions. The difference between a good developer and a bad one isn't whether they use external resources, it's whether they understand what they're using and give credit where it's due.

You're doing it right! 🙌

 (\(\
 ( -.-)
 o_(")(")
 [thumbs up!]